package 课上练习0421_scala

import scala.util.Random

/**
 * 模式匹配
 */
object Scala_03_match_case {
  def main(args: Array[String]): Unit = {
    println(valueMatch())
    classMatch()
    typeMatch()
    stringMatch
    println(arrayMatch)
    println(listMatch)
    println(tupleMatch)
  }

  // 值匹配
  def valueMatch() = {
    val a = '1'
    val b = '2'
    val c = '*'

    /*
    注意：
    1、如果都匹配不上，直接报异常
    2、如果想匹配多个条件，可以使用 |
    3、当某一个case成功匹配后，直接跳出整个的match，并且在case后面不需要写break
    4、我们可以给选项添加守卫
     */
    a match {
      case 'a' | 'b' => println("a")
      case 1 => println(1)
      case '*' => println("*")
      case _ if Character.isDigit(a) => {
        println("都不符合")
        Character.digit(a, 10)
      }
    }
  }

  // 类型匹配
  def classMatch() = {
    val arr = Array("hadoop", 11, 2.3, 'a')
    val obj = arr(Random.nextInt(arr.length))
    obj match {
      case x: String => println(s"String=>$x")
      case x: Int => println(s"Int=>$x")
      case x: Double => println(s"Double=>$x")
      case x: Char => println(s"Char=>$x")
      case _ => println("啥也不是")
    }
  }

  // 泛型匹配
  def typeMatch() = {
    val intList = List(1, 2, 3)
    val strList = List("string", "string")
    // list由于有泛型擦除的原因，所以都会匹配成功
    intList match {
      case _: List[Int] => println("匹配Int")
    }
    intList match {
      case _: List[String] => println("匹配String")
    }
    // array底层使用java基本数据类型数组存储，不受泛型擦除影响
    val intArray = Array(1, 2, 3)
    intArray match {
      case _: Array[Int] => println("匹配Int")
    }
//    intArray match {
//      case _: Array[String] => println("匹配Array")
//    }
  }

  // 集合匹配--匹配字符串
  def stringMatch = {
    val arr = Array("hadoop", "spark", "flink")
    val obj = arr(Random.nextInt(arr.length))

    obj match {
      case "hadoop" => println("hadoop")
      case _ => println("这啥啊这是")
    }
  }


  // 集合匹配
  def arrayMatch = {
    val array = Array(12, 2, 3, 4, 5)
    array match {
      case Array(12) => "只有一项12的精准匹配"
      case Array(x, y, z) => s"成功匹配三个元素：$x, $y, $z"
      case Array(12, _*) => "匹配12开头的数组"
      case _ => "都不是"
    }
  }

  // 列表匹配
  def listMatch: String = {
    val list = List(23, 34, 56, 78, 99)
    list match {
      case 23 :: Nil => "精准匹配，列表中只有23一项"
      case x :: y :: Nil => "只有两项，并且赋值，" + x + ", " + y
      case 23 :: _ => "23 ..."
      case List(1, 2, x) => s"$x"
      case _ => "都不是"
    }
  }

  // 元组匹配
  def tupleMatch = {
    val tuple = (1, 3, 5)
    tuple match {
      case (1, _, _) => "1...."
      case (x, 0, 0) => x.toString
      case _ => "啥也不是"
    }
  }

  // 样例类匹配
  class Email(var sender: String, var message: String)
  object Email {
    def unapply(arg: Email): Option[(String, String)] = ???
  }
}
